package cn.dinkevin.xui.util;

import android.support.annotation.NonNull;
import android.util.Log;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串处理工具类
 *
 * @author chengpengfei
 */
public final class StringUtil {

    private StringUtil() {}

    /**
     * 截取字符串
     *
     * @param source    源数据
     * @param maxLength 最大长度
     * @param suffix    如果给定的字符长度大于指定的最大长度，截取后所加的后缀
     * @return 结果
     */
    public static String cutString(@NonNull String source, @NonNull int maxLength, String suffix) {
        if (source != null) {
            if (source.length() > maxLength) {
                return source.substring(0, maxLength) + (StringUtil.isEmpty(suffix) ? "" : suffix);
            }
        }
        return source;
    }

    /**
     * 截取字符串并进行替换
     *
     * @param source 源数据
     * @return 结果
     */
    public static String replaceString(String source) {
        try {
            return source.replaceAll("\r", "\r\n");
        } catch (Exception e) {
            return source;
        }
    }


    /**
     * 判断该字段是否为空，
     *
     * @param str 如果 str 为 null或者长度为 0 则返回 null
     */
    public static boolean isEmpty(String str) {
        if (null == str || str.trim().length() < 1) {
            return true;
        }
        return false;
    }

    /**
     * 判断指定的字段不为空
     *
     * @param str
     * @return true -> 该字段不为空;false -> 为空
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * 获取字符长度
     *
     * @param content
     * @return
     */
    public static int length(String content) {
        return isEmpty(content) ? 0 : content.length();
    }

    /**
     * 处理网络路径中包含非 ASCII 码的文字
     *
     * @param url
     * @return 结果
     */
    public static String encodeHttpUrl(String url) {
        StringBuffer buffer = new StringBuffer();
        try {
            for (int i = 0; i < url.length(); i++) {
                char ch = url.charAt(i);
                String encodeCh = String.valueOf(ch);
                if (ch > 127 || ch < 33) {
                    encodeCh = URLEncoder.encode(encodeCh, g_charset.name());
                }
                buffer.append(encodeCh);
            }
        } catch (UnsupportedEncodingException e) {
            LogUtil.e(url, Log.getStackTraceString(e));
        }
        return buffer.toString();
    }


    /**
     * byte数组输出到十六制字符串
     *
     * @param data
     * @return
     */
    public static String byte2Hex(byte[] data) {
        StringBuffer buffer = new StringBuffer();
        if (null != data) {
            for (byte b : data) {
                int temp = b & 0xff;
                String ch = Integer.toHexString(temp);
                if (ch.length() < 2)
                    ch = "0" + ch;
                buffer.append(ch);
                buffer.append(" ");
            }
        }
        return buffer.toString();
    }



    public static char[] byte2Char(byte[] data){
        if(null == data || data.length == 0) return new char[0];
        char[] result = new char[data.length];
        for(int i = 0;i < data.length;i++){
            result[i] = (char)(data[i] & 0xff);
        }
        return result;
    }


    public static String char2String(char[] data){
        StringBuffer buffer = new StringBuffer();
        if(null != data && data.length > 0){
            buffer.append(data);
        }
        return buffer.toString();
    }


    /**
     * 十六制字符串到byte数组
     *
     * @param data
     * @return
     */
    public static byte[] hex2Byte(String data) {
        if (null == data || data.length() == 0 || data.length() % 2 != 0) {
            return new byte[0];
        }
        byte[] result = new byte[data.length() / 2];
        char[] source = data.toCharArray();
        for (int i = 0; i < source.length; i += 2) {
            String num = source[i] + "" + source[i + 1];
            int temp = Integer.parseInt(num, 16);
            result[i / 2] = (byte) (temp & 0xff);
        }
        return result;
    }

    /**
     * 编码方式，默认为 UTF-8
     */
    private static Charset g_charset = Charset.forName("UTF-8");

    /**
     * 获取当前默认的编码方式
     *
     * @return
     */
    public static Charset getCharset() {
        return g_charset;
    }

    /**
     * 设置编码方式
     *
     * @param charset
     */
    public static void setCharset(Charset charset) {
        g_charset = charset;
    }

    /**
     * 字符串转换到 byte 数组
     *
     * @param data
     * @return
     */
    public static byte[] getBytes(String data) {
        if (!isEmpty(data)) {
            return data.getBytes(getCharset());
        }
        return new byte[0];
    }

    /**
     * byte 数组转换到字符串
     *
     * @param data
     * @return
     */
    public static String encode(byte[] data) {
        if (null != data && data.length > 0) {
            return new String(data, getCharset());
        }
        return null;
    }

    /**
     * 索引
     *
     * @param source
     * @param keywords
     * @return
     */
    public static int indexOf(String source, String keywords) {
        if (isEmpty(source) || isEmpty(keywords)) return -1;
        return source.indexOf(keywords);
    }

    /**
     * 格式化手机号
     * </p>
     * <pre>
     *     18512525714 格式转化到 185-1252-5714
     * </pre>
     *
     * @param mobile
     * @return
     */
    public static String formatMobile(String mobile) {
        if (RegularUtil.isMobile(mobile)) {
            String result = mobile.substring(0, 3);
            result += "-";
            result += mobile.substring(3, 7);
            result += "-";
            result += mobile.substring(7);
            return result;
        }
        return mobile;
    }

    /**
     * 去除 Content 两边的特殊字符
     *
     * @param content 待处理的内容
     * @param special 待检测的特殊字符
     * @return 结果字符
     */
    public static String trim(String content, String special) {
        if (isEmpty(content)) {
            return "";
        }

        if (content.startsWith(special)) {
            content = content.substring(1);
        }

        if (content.endsWith(special))
            content = content.substring(0, content.length());
        return content;
    }

    /**
     * 去除指定文本中的特殊符号，例如：回车、水平制表符、空格、换行这些用来显示空白的符号
     *
     * @param content
     * @return
     */
    public static String trimSpace(String content) {
        if (isEmpty(content))
            return "";

        Pattern p = Pattern.compile("\\s*|\t|\r|\n");
        Matcher m = p.matcher(content);
        content = m.replaceAll("");
        return content;
    }

    /**
     * 删除内容首尾两端空格与换行
     *
     * @param content
     * @return
     */
    public static String trimEndsSpace(String content) {

        if (isEmpty(content)) return "";

        Pattern p = Pattern.compile("^\\s*|\\s*$");
        Matcher m = p.matcher(content);
        String result = m.replaceAll("");
        return result;
    }

    /**
     * 格式化字符串
     *
     * @param msg  格式数据
     * @param args 参数
     * @return 格式化后的字符串
     */
    public static String formatString(final String msg, Object... args) {
        return String.format(Locale.ENGLISH, msg, args);
    }

    /**
     * 字符串内容比较
     *
     * @param s1
     * @param s2
     * @return
     */
    public static boolean equal(String s1, String s2) {
        if (null == s1 && null == s2) return true;
        if (null == s1 && null != s2) return false;
        if (null != s1 && null == s2) return false;
        return s1.equals(s2);
    }
}
